home *** CD-ROM | disk | FTP | other *** search
/ The Very Best of Atari Inside / The Very Best of Atari Inside 1.iso / sharew / accs / drupatch / install.c next >
Encoding:
C/C++ Source or Header  |  1985-07-21  |  5.2 KB  |  280 lines
  1. /*
  2.  *        Installierung der Druckeranpassungstabelle PRINTER.DOT
  3. */
  4.  
  5. #include  <osbind.h>
  6. #include  <gemdefs.h>
  7. #include  <define.h>
  8.  
  9. #define    byte    unsigned char
  10.  
  11. byte    *buffer;            /* Puffer fuer die Eingabe    */
  12. long    buf_size = 8000;    /* Puffergroesse            */
  13. char    path[64];            /* Name der Eingabedatei    */
  14. int        file;                /* Eingabedatei - handle    */
  15. long    file_size;            /* Laenge der Eingabedatei    */
  16.  
  17. main ()
  18. {
  19.     appl_init ();
  20.     if (file_select (path, "*.TAB"))
  21.         tab_set();
  22.     appl_exit ();
  23. }
  24.  
  25.  
  26. /*****   Quelldatei einlesen   *****/
  27.  
  28. int        eof;        /* Flag fuer Dateiende */
  29.  
  30. read_char ()
  31. {
  32.     static byte  *s;
  33.     static long  n;                /* Pufferinhalt */
  34.  
  35.     if (n <= 0) {                        /* Puffer leer ? */
  36.         if (file_size <= 0) {
  37.             eof = TRUE;
  38.             return (-1);
  39.         }
  40.         n = file_size < buf_size ? file_size : buf_size;
  41.         file_size -= n;
  42.         Fread (file, n, s = buffer);
  43.     }
  44.     n--;
  45.     return (*s++);
  46. }
  47.  
  48.  
  49. /*****   Lies naechstes Quelltextzeichen   *****/
  50.  
  51. byte    line[160];            /* Eingabezeile        */
  52. int        ch;                    /* Zeichen            */
  53. int        line_len;            /* Zeilenlaenge        */
  54. int        line_number;        /* akt. Zeile        */
  55. int        column;                /* akt. Spalte        */
  56. int        new_char;            /* ch ist aktuell    */
  57.  
  58. get_char ()
  59. {
  60.     new_char = TRUE;
  61.  
  62.     if (column >= line_len)
  63.         if (!get_line())
  64.             return (ch = -1);                /* Dateiende */
  65.  
  66.     while ((ch = line[column++]) == '\r');
  67.  
  68.     return (ch);
  69. }
  70.  
  71.  
  72. /*****   Lies naechste Quelltextzeile   *****/
  73.  
  74. get_line ()
  75. {
  76.     register byte  *l = line;
  77.     register int   i, c;
  78.  
  79.     if (eof)
  80.         return (FALSE);
  81.  
  82.     for (i = 0; i < 160;) {
  83.         if ((c = read_char()) < 0)
  84.             break;
  85.         if (c == '\t') {            /* Tabulator */
  86.             do
  87.                 *l++ = ' ';
  88.             while (++i & 0x7);        /* Tab size = 8 */
  89.             continue;
  90.         }
  91.         i++;
  92.         if ((*l++ = c) == '\n')        /* Zeilentrenner */
  93.             break;
  94.     }
  95.     line_number++;
  96.     column = 0;
  97.     return (line_len = i);   
  98. }
  99.  
  100.  
  101. /*****   Lies naechstes Symbol -> symbol   *****/
  102.  
  103. int        symbol;
  104. byte    value;
  105.  
  106. #define    EOF        0
  107. #define    RETURN    1
  108. #define    NUMBER    2
  109. #define    COMMA    3
  110.  
  111. new_sym ()
  112. {
  113.     return (symbol = get_symbol());
  114. }
  115.  
  116. get_symbol ()
  117. {
  118.     register int    comment = FALSE;    /* Flag fuer Kommentar */
  119.     register int    c;                    /* Quelltextzeichen */
  120.     register long    n;
  121.  
  122.     c = new_char ? ch : get_char();
  123.  
  124.     while (TRUE) {
  125.         if (c < 0)                        /* Dateiende */
  126.             return (EOF);
  127.         if (c == '\\') {                /* Fortsetzungszeile */
  128.             if (get_char() == '\n')
  129.                 goto next;
  130.             if (!comment)
  131.                 error ("'\\n' expected");
  132.             continue;
  133.         }
  134.         if (c == '\n') {                /* Zeilenende */
  135.             new_char = FALSE;
  136.             return (RETURN);
  137.         }
  138.         if (c == '*')                    /* Kommentaranfang */
  139.             comment = TRUE;
  140.         if (comment)
  141.             goto next;
  142.         if (c == ' ')
  143.             goto next;
  144.         if (c == ',') {
  145.             new_char = FALSE;
  146.             return (COMMA);
  147.         }
  148.         if ((n = hex(c)) >= 0) {
  149.             while ((c = hex(get_char())) >= 0) {
  150.                 n <<= 4;
  151.                 n += c;
  152.             }
  153.             value = n;
  154.             return (NUMBER);
  155.         }
  156.  
  157.         error ("lexical error");
  158.  
  159. next:    c = get_char();
  160.  
  161.     }
  162. }
  163.  
  164.  
  165. /*****   Fehlerbehandlung   *****/
  166.  
  167. error (message)
  168. char  message[];
  169. {
  170.     static int    last_line;
  171.     char  position[4];
  172.  
  173.     if (!last_line)
  174.         if (form_alert (1, "[1][Error detected][ Print | Cancel]") == 2)
  175.             Pterm (1);
  176.     if (line_number != last_line) {
  177.         out ("\r\n");
  178.         Fwrite (3, (long) line_len, line);
  179.     }
  180.     last_line = line_number;
  181.     out ("\tcolumn  ");
  182.     itoa (column, position);
  183.     out (position);
  184.     out ("\t");
  185.     out (message);
  186.     out ("\r\n");
  187. }
  188.  
  189. out (s)
  190. register char  *s;
  191. {
  192.     while (*s)
  193.         Cprnout (*s++);
  194. }
  195.  
  196.  
  197. /*****   Konvertierungstabelle aufbauen   *****/
  198.  
  199. tab_set ()
  200. {
  201.     register int    *convert;        /* Zeichentabelle -> Code */
  202.     register byte    *code;            /* enthaelt die Ersetzungszeichen */
  203.     register int    fh, n;
  204.     register int    offset = 0;
  205.     register int    old;
  206.  
  207.     if ((file = Fopen (path, 0)) < 0) {
  208.         form_alert (1, "[3][Can't open input file ... ][ Cancel ]");
  209.         return;
  210.     }
  211.     file_size = Fseek (0L, file, 2);
  212.     Fseek (0L, file, 0);
  213.  
  214.     convert = (int*) Malloc (768L);
  215.     buffer = (byte*) Malloc (buf_size);
  216.     if (!(convert  &&  buffer)) {
  217.         form_alert (1, "[3][not enough memory available ... ][ Cancel ]");
  218.         return;
  219.     }
  220.     code = (byte*) (convert += 256);
  221.     for (n = 256; n > 0; n--)
  222.         *--convert = -1;
  223.  
  224.     fh = Fcreate ("printer.dot", 0);
  225.     Fwrite (fh, 512L, convert);            /* reserviere 512 bytes */
  226.  
  227.     new_sym();                /* lies erstes Symbol */
  228.  
  229.     while (TRUE) {
  230.         if (symbol == NUMBER) {
  231.             old = value;                    /* altes Zeichen */
  232.             n = 1;
  233.             while (TRUE) {
  234.                 if (new_sym() == COMMA)        /* optional */
  235.                     if (new_sym() != NUMBER)
  236.                         error ("NUMBER expected");
  237.                 if (symbol != NUMBER)
  238.                     break;
  239.                 code[n++] = value;            /* Ersetzungszeichen */
  240.             }
  241.             if (symbol == RETURN) {
  242.                 code[0] = (byte) n;
  243.                 Fwrite (fh, (long) n, code);
  244.                 convert[old] = offset;
  245.                 offset += n;
  246.                 new_sym();
  247.             } else 
  248.                 error ("missing 'RETURN'");
  249.         }
  250.         else if (symbol == EOF)
  251.             break;
  252.         else {
  253.             if (symbol != RETURN)
  254.                 error ("Symbol ignored");
  255.             new_sym();
  256.         }
  257.     }
  258.     Fseek (0L, fh, 0);
  259.     Fwrite (fh, 512L, convert);
  260.     Fclose (fh);
  261.     Fclose (file);
  262.  
  263. }
  264.  
  265.  
  266. /*****   Hexadezimalzahl ?   *****/
  267.  
  268. hex (c)
  269. register int  c;
  270. {
  271.     if (c > 0x60)
  272.         c -= 0x20;            /*  -> Grossbuchstabe  */
  273.     if (c > '9') {
  274.         c -= 'A';
  275.         if (c < 0 || c > 5)
  276.             return (-1);
  277.         return (c + 10);
  278.     }
  279.     return (c - '0');
  280. }